package io.youngledo.usb.connection;

import io.youngledo.usb.license.Feature;
import io.youngledo.usb.license.FeatureGate;
import io.youngledo.usb.license.LicenseManager;
import io.youngledo.usb.storage.StorageConfig;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

/// 连接管理器
///
/// 负责管理多个存储连接的生命周期。
///
/// ## 许可证限制
/// - **社区版**: 最多2个同时打开的连接（可添加多个，但只能同时打开2个）
/// - **专业版**: 无限制同时打开的连接数
public class ConnectionManager {
    /// 社区版最大同时打开连接数
    private static final int COMMUNITY_MAX_ACTIVE_CONNECTIONS = 2;
    private final Map<String, StorageConnection> connections = new ConcurrentHashMap<>();
    private final ObservableList<StorageConnection> connectionList = FXCollections.observableArrayList();
    private StorageConnection activeConnection;

    /// 添加新连接
    ///
    /// @param config 存储配置
    /// @param customName 自定义名称
    /// @return 连接ID
    public String addConnection(StorageConfig config, String customName) {
        // 生成显示名称
        String displayName = (customName != null && !customName.trim().isEmpty()) ?
                customName.trim() : ConnectionIdentifier.generateDisplayName(config);

        // 确保名称唯一
        Set<String> existingNames = new HashSet<>();
        connections.values().forEach(conn -> existingNames.add(conn.getDisplayName()));
        displayName = ConnectionIdentifier.ensureUniqueName(displayName, existingNames);

        // 创建连接
        String id = UUID.randomUUID().toString();
        StorageConnection connection = new StorageConnection(id, displayName, config);

        // 添加到管理器（不限制添加数量）
        connections.put(id, connection);
        connectionList.add(connection);

        return id;
    }

    /**
     * 移除连接
     */
    public void removeConnection(String connectionId) {
        StorageConnection connection = connections.get(connectionId);
        if (connection == null) {
            return;
        }

        // 如果连接处于活动状态，先断开
        if (connection.isConnected()) {
            connection.disconnect();
        }

        // 如果是当前活动连接，清除活动状态
        if (connection.equals(activeConnection)) {
            activeConnection = null;
        }

        connections.remove(connectionId);
        connectionList.remove(connection);
    }

    /**
     * 获取连接
     */
    public StorageConnection getConnection(String connectionId) {
        return connections.get(connectionId);
    }

    /**
     * 获取所有连接
     */
    public Collection<StorageConnection> getAllConnections() {
        return connections.values();
    }

    /// 断开所有连接
    public void disconnectAll() {
        connections.values().forEach(StorageConnection::disconnect);
        activeConnection = null;
    }

    /// 检查是否可以打开更多连接
    ///
    /// 社区版限制同时打开的连接数，而非总连接数。
    /// 用户可以添加任意数量的连接配置，但只能同时打开有限数量的连接。
    ///
    /// @return 如果可以打开更多连接返回true
    public boolean canOpenMoreConnections() {
        // 如果是专业版，无限制
        if (FeatureGate.isEnabled(Feature.UNLIMITED_CONNECTIONS)) {
            return true;
        }

        // 社区版限制：统计当前已打开的连接数
        long activeCount = connections.values().stream()
                .filter(StorageConnection::isConnected)
                .count();

        return activeCount < COMMUNITY_MAX_ACTIVE_CONNECTIONS;
    }

    /// 获取当前活动连接数
    ///
    /// @return 当前已打开的连接数
    public int getActiveConnectionCount() {
        return (int) connections.values().stream()
                .filter(StorageConnection::isConnected)
                .count();
    }

    /// 获取当前连接数
    ///
    /// @return 当前连接总数
    public int getConnectionCount() {
        return connections.size();
    }

    /// 获取最大允许活动连接数
    ///
    /// @return 最大活动连接数（社区版返回限制数，专业版返回-1表示无限制）
    public int getMaxActiveConnections() {
        return FeatureGate.isEnabled(Feature.UNLIMITED_CONNECTIONS) ?
                -1 : COMMUNITY_MAX_ACTIVE_CONNECTIONS;
    }

    /// 获取活动连接数限制描述
    ///
    /// @return 活动连接数限制的文字描述
    public String getActiveConnectionLimitDescription() {
        if (FeatureGate.isEnabled(Feature.UNLIMITED_CONNECTIONS)) {
            return "无限制";
        }
        return String.format("%d/%d", getActiveConnectionCount(), COMMUNITY_MAX_ACTIVE_CONNECTIONS);
    }

    /// 连接数超限异常
    public static class ConnectionLimitExceededException extends RuntimeException {
        public ConnectionLimitExceededException(String message) {
            super(message);
        }
    }

    /**
         * 连接统计信息
         */
        public record ConnectionStats(int total, int connected, int disconnected, Map<String, Integer> typeCount) {

        @Override
            public String toString() {
                return String.format("总连接: %d, 已连接: %d, 未连接: %d", total, connected, disconnected);
            }
        }
}